@abstractframework/continuum 0.3.0 → 0.3.1

package/README.md

@@ -18,7 +18,8 @@ cockpit (board-first, kanban/scrum-inspired — see
 - **Backlog** — the full catalog power view (all kinds incl. recurrent /
   deprecated / trash, search, batch execute, merge, AI assist + advisor).
 - **Agents & Entities** — the workforce: the configured execution agent
-  (executor is a pluggable seam — Codex CLI today), the advisor agent, a
+  (Codex CLI, Claude Code, Cursor Agent or AbstractCode — a gateway
+  setting), the advisor agent, a
   track record from execution history, and gateway entities with their
   skills.
 - **Team** — an [agora](docs/configuration.md#team-page-agora-hub) hub
@@ -32,7 +33,11 @@ cockpit (board-first, kanban/scrum-inspired — see
 - **Services** — control managed prod/UAT processes (start / stop /
   restart / redeploy) and write-only environment variables. This surface is
   high trust: see [SECURITY.md](SECURITY.md) before exposing it.
-- **Settings** — gateway session sign-in and AI preferences.
+- **Settings** — gateway sign-in, execution defaults (UAT or inplace), AI
+  and voice preferences, and **Gateway administration**: the backlog
+  folder, exec runner, executor and process manager, each shown with where
+  its value comes from (launch flag, setting, environment (legacy), or
+  default). Only a gateway admin can change them.
 
 Executing a Ready item is gated by an advisory **Definition of Ready**
 checklist (type, real summary, acceptance criteria, test commands — parsed
@@ -41,18 +46,20 @@ review shows the acceptance criteria as a **Definition of Done** checklist.
 
 The observer app ([AbstractObserver](https://github.com/lpalbou/AbstractObserver))
 watches and discusses the running system; this app develops and deploys it.
-The pipeline is executor-agnostic by design: the gateway currently runs
-executions through the Codex CLI, but the executing agent is a pluggable
-seam and the UI reads the executor identity from the gateway's exec config
-(see [docs/architecture.md](docs/architecture.md)).
+The pipeline is executor-agnostic: the gateway's `executor` setting picks
+the agent that runs items (`codex` by default; also `claude`,
+`cursor-agent`, `abstractcode`), and the UI reads the executor identity from
+the gateway's exec config (see [docs/architecture.md](docs/architecture.md)).
 
 ## Install and run
 
-Requires Node.js ≥ 18 and a running Run Gateway
-([AbstractGateway](https://github.com/lpalbou/AbstractGateway), default
-`http://127.0.0.1:8080`). AbstractGateway 0.4.1 or newer is needed for the
-backlog folder panel and the Settings → Gateway administration controls; an
-older gateway shows the Board's *folder not available* panel instead.
+Requirements:
+
+- Node.js ≥ 18.
+- **AbstractGateway 0.4.1 or newer** (the supported gateway; default
+  `http://127.0.0.1:8080`). See
+  [AbstractGateway](https://github.com/lpalbou/AbstractGateway). Against an
+  older gateway the Board shows its *folder not available* panel.
 
 ```bash
 npx @abstractframework/continuum
@@ -65,14 +72,25 @@ Open `http://localhost:3002` and sign in with a gateway user and token (the
 connection badge at the bottom of the sidebar). The token is exchanged
 server-side for an HttpOnly session cookie and never stored in the browser.
 
-Common environment variables (full list in
+The server is configured with launch flags or saved settings (full list in
 [docs/configuration.md](docs/configuration.md), or `abstractcontinuum --help`):
 
-- `PORT` (default `3002`), `HOST` (default `127.0.0.1`)
-- `ABSTRACTCONTINUUM_GATEWAY_URL` (or `ABSTRACTGATEWAY_URL`) — the gateway
-  this deployment talks to (default `http://127.0.0.1:8080`)
-- `ABSTRACTCONTINUUM_HUB_URL` / `ABSTRACTCONTINUUM_HUB_SEAT` — the agora hub
-  and operator seat for the Team page
+```bash
+abstractcontinuum --port 3002 --gateway-url http://127.0.0.1:8080 --hub-seat alice
+abstractcontinuum config set hub_seat alice    # saved in ~/.abstractcontinuum/settings.json
+abstractcontinuum config get                   # every setting and where it comes from
+```
+
+- `--port` (default `3002`), `--host` (default `127.0.0.1`)
+- `--gateway-url` — the gateway this deployment talks to (default
+  `http://127.0.0.1:8080`)
+- `--hub-url` / `--hub-seat` / `--hub-token-file` — the agora hub, your seat
+  and its key for the Team page. The hub seat is also on the Settings page.
+
+A fresh gateway needs no backlog setup: it keeps its own backlog folder, and
+the Board opens on **Your backlog is empty** with **Create your first item**.
+To point the Board at a project, or to enable executions, see
+[docs/getting-started.md](docs/getting-started.md#your-backlog).
 
 Before exposing the console beyond localhost, read
 [docs/security.md](docs/security.md): a signed-in user can redeploy services.
@@ -89,7 +107,7 @@ git clone https://github.com/lpalbou/AbstractUIC.git abstractuic
 git clone https://github.com/lpalbou/AbstractContinuum.git abstractcontinuum
 cd abstractcontinuum
 npm install
-npm run dev        # vite dev server on :3003 (proxies /api to :8080)
+npm run dev        # vite dev server on :3002 (proxies /api to the gateway)
 npm test           # vitest (unit + jsdom component tests)
 npm run build      # production build into dist/
 npm start          # serve dist/ + the app-origin gateway session proxy on :3002
@@ -103,7 +121,8 @@ See [CONTRIBUTING.md](CONTRIBUTING.md) for the development workflow.
 - [docs/getting-started.md](docs/getting-started.md) — first run and first execution
 - [docs/architecture.md](docs/architecture.md) — components, data flow, design boundaries
 - [docs/api.md](docs/api.md) — the gateway API families this app consumes
-- [docs/configuration.md](docs/configuration.md) — environment variables and settings
+- [docs/configuration.md](docs/configuration.md) — server environment variables, gateway settings, browser settings
+- [docs/conventions.md](docs/conventions.md) — the work-item grammar the Board reads
 - [docs/security.md](docs/security.md) — trust model (read before deploying)
 - [docs/faq.md](docs/faq.md) / [docs/troubleshooting.md](docs/troubleshooting.md)
 - [CHANGELOG.md](CHANGELOG.md) — release history

package/bin/cli.js

@@ -10,52 +10,159 @@
 
 import * as http from 'http';
 import { readFileSync, existsSync, statSync } from 'fs';
-import { homedir } from 'os';
 import { join, extname, dirname } from 'path';
 import { fileURLToPath } from 'url';
 import { createGatewaySessionProxy } from '@abstractframework/app-server';
 import { createHubProxy } from './hub_proxy.js';
+import {
+  SETTINGS,
+  SOURCE_WORDS,
+  apply_session_proxy_gates,
+  createLiveSettings,
+  createSettingsRoute,
+  default_settings_path,
+  display_value,
+  expand_home,
+  parse_args,
+  read_settings_file,
+  resolve_settings,
+  setting_spec,
+  update_settings_file,
+} from './settings.js';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const DIST_DIR = join(__dirname, '..', 'dist');
 
-const argv = process.argv.slice(2);
-if (argv.includes('--version') || argv.includes('-v')) {
+function help_text() {
+  const lines = [];
+  const col = (left, right) => (left.length >= 30 ? `  ${left}\n${' '.repeat(32)}${right}` : `  ${left.padEnd(30)}${right}`);
+  lines.push('Usage:');
+  lines.push('  abstractcontinuum [options]                 start the console server');
+  lines.push('  abstractcontinuum config get [setting]      show settings and their sources');
+  lines.push('  abstractcontinuum config set <setting> <value>');
+  lines.push('  abstractcontinuum config set hub_token --from-file <path>');
+  lines.push('  abstractcontinuum config unset <setting>');
+  lines.push('  abstractcontinuum config path               print the settings file path');
+  lines.push('');
+  lines.push('Serves the AbstractContinuum console and proxies /api/* to a Run Gateway');
+  lines.push('through a same-origin session proxy.');
+  lines.push('');
+  lines.push('Options (each is also a saved setting; its name follows "setting"):');
+  for (const spec of SETTINGS) {
+    const left = spec.type === 'bool' ? spec.flag : `${spec.flag} ${spec.metavar}`;
+    const def = spec.type === 'bool' ? 'off' : spec.default === '' ? 'none' : String(spec.default);
+    lines.push(col(left, spec.help));
+    lines.push(`${' '.repeat(32)}default ${def}; setting ${spec.key}`);
+    if (spec.key === 'hub_token') {
+      lines.push(col('--hub-token-file <path>', 'read the hub token from a file (never printed)'));
+      lines.push(`${' '.repeat(32)}setting hub_token`);
+    }
+  }
+  lines.push(col('--settings-file <path>', 'settings file'));
+  lines.push(`${' '.repeat(32)}default ~/.abstractcontinuum/settings.json`);
+  lines.push(col('--help', 'show this help'));
+  lines.push(col('--version', 'print the version'));
+  lines.push('');
+  lines.push('On/off options take --option, --option=off or --no-option.');
+  lines.push('Precedence: launch flag > settings file > environment (legacy) > default.');
+  lines.push('The hub seat can also be set on the Settings page.');
+  lines.push('Legacy fallback: the environment variables listed in the configuration guide are');
+  lines.push('still read when neither a flag nor a setting is set.');
+  lines.push('');
+  lines.push('Documentation: https://github.com/lpalbou/AbstractContinuum#readme');
+  return lines.join('\n');
+}
+
+const parsed = parse_args(process.argv.slice(2));
+if (parsed.error) {
+  console.error(`abstractcontinuum: ${parsed.error}`);
+  process.exit(2);
+}
+if (parsed.command === 'version') {
   const pkg = JSON.parse(readFileSync(join(__dirname, '..', 'package.json'), 'utf8'));
   console.log(pkg.version);
   process.exit(0);
 }
-if (argv.includes('--help') || argv.includes('-h')) {
-  console.log(`Usage: abstractcontinuum [--help] [--version]
-
-Serves the AbstractContinuum console and proxies /api/* to a Run Gateway
-through a same-origin session proxy. Configuration is environment-driven:
-
-  PORT                            HTTP port (default 3002)
-  HOST                            bind address (default 127.0.0.1)
-  ABSTRACTCONTINUUM_GATEWAY_URL   gateway URL (fallback ABSTRACTGATEWAY_URL,
-                                  default http://127.0.0.1:8080)
-  ABSTRACTCONTINUUM_HUB_URL       agora hub for the Team page (fallback
-                                  AGORA_HUB_URL, default http://127.0.0.1:8765)
-  ABSTRACTCONTINUUM_HUB_SEAT      hub seat the Team page acts as (default laurent)
-  ABSTRACTCONTINUUM_HUB_KEYS      hub key store (default ~/.agora/keys.json)
-  ABSTRACTCONTINUUM_HUB_KEY       hub API key (overrides the key store)
-
-Documentation: https://github.com/lpalbou/AbstractContinuum#readme`);
+if (parsed.command === 'help') {
+  console.log(help_text());
   process.exit(0);
 }
 
-const PORT = process.env.PORT || 3002;
+const SETTINGS_PATH = parsed.settings_file || default_settings_path();
+
+if (parsed.command === 'config') {
+  process.exit(run_config(parsed));
+}
+
+/** `abstractcontinuum config get|set|unset|path` — same keys as the flags. */
+function run_config(p) {
+  const { action, key, value } = p.config;
+  try {
+    if (action === 'path') {
+      console.log(SETTINGS_PATH);
+      return 0;
+    }
+    if (action === 'set' || action === 'unset') {
+      let v = action === 'unset' ? null : value;
+      if (action === 'set' && p.from_file) {
+        v = readFileSync(p.from_file, 'utf8').trim();
+        if (!v) throw new Error(`${p.from_file} is empty`);
+      }
+      update_settings_file(SETTINGS_PATH, key, v);
+      const spec = setting_spec(key);
+      const shown = action === 'unset' ? '(removed)' : display_value(spec, read_settings_file(SETTINGS_PATH)[key]);
+      console.log(`${key} = ${shown}  (${SETTINGS_PATH})`);
+      return 0;
+    }
+    // get
+    const { settings, problems } = resolve_settings({ flags: p.flags, file: read_settings_file(SETTINGS_PATH), env: process.env });
+    for (const msg of problems) console.error(`warning: ${msg}`);
+    if (key) {
+      console.log(display_value(setting_spec(key), settings[key].value));
+      return 0;
+    }
+    const width = Math.max(...SETTINGS.map((s) => s.key.length)) + 2;
+    for (const spec of SETTINGS) {
+      const { value: v, source } = settings[spec.key];
+      console.log(`${spec.key.padEnd(width)}${display_value(spec, v)}  (${SOURCE_WORDS[source]})`);
+    }
+    console.log(`\nsettings file: ${SETTINGS_PATH}`);
+    return 0;
+  } catch (e) {
+    console.error(`abstractcontinuum config: ${e && e.message ? e.message : e}`);
+    return 1;
+  }
+}
+
+// A corrupt settings file stops the start (running on silent defaults
+// would, e.g., drop a saved seat without a word).
+try {
+  read_settings_file(SETTINGS_PATH);
+} catch (e) {
+  console.error(`abstractcontinuum: cannot read the settings file ${SETTINGS_PATH}: ${e && e.message ? e.message : e}`);
+  process.exit(2);
+}
+
+const settings = createLiveSettings({
+  flags: parsed.flags,
+  settingsPath: SETTINGS_PATH,
+  env: process.env,
+  onProblem: (msg) => console.error(`warning: ${msg}`),
+});
+const AT_START = settings.get();
+
+const PORT = AT_START.port.value;
 // Default bind is LOOPBACK (entity's c1768 SSRF finding against the shared
 // session proxy, plus a continuum-specific amplifier: this server also
 // mounts the hub proxy carrying the OPERATOR's seat key — a LAN peer
 // reaching the port could author hub messages as the operator). Wider
-// binds are an explicit deployment choice via HOST.
-const HOST = process.env.HOST || '127.0.0.1';
-const DEFAULT_GATEWAY_URL = String(process.env.ABSTRACTCONTINUUM_GATEWAY_URL || process.env.ABSTRACTGATEWAY_URL || 'http://127.0.0.1:8080').trim().replace(/\/+$/, '') || 'http://127.0.0.1:8080';
-const HUB_URL = String(process.env.ABSTRACTCONTINUUM_HUB_URL || process.env.AGORA_HUB_URL || 'http://127.0.0.1:8765').trim().replace(/\/+$/, '');
-const HUB_SEAT = String(process.env.ABSTRACTCONTINUUM_HUB_SEAT || 'laurent').trim();
-const HUB_KEYS_PATH = String(process.env.ABSTRACTCONTINUUM_HUB_KEYS || join(homedir(), '.agora', 'keys.json'));
+// binds are an explicit deployment choice (--host).
+const HOST = AT_START.host.value;
+const DEFAULT_GATEWAY_URL = AT_START.gateway_url.value;
+
+// The session proxy reads its hardening gates from the environment only;
+// hand it the resolved values (flag > setting > environment > default).
+apply_session_proxy_gates(AT_START, process.env);
 
 const MIME_TYPES = {
   '.html': 'text/html',
@@ -120,8 +227,8 @@ function serveFile(res, filePath) {
   }
 }
 
-// Cookies abstractcontinuum_gateway_*, header x-abstractcontinuum-csrf, and
-// the ABSTRACTCONTINUUM_* / ABSTRACTGATEWAY_* env gates all derive from appId.
+// Cookies abstractcontinuum_gateway_* and header x-abstractcontinuum-csrf
+// derive from appId.
 const gatewaySessionProxy = createGatewaySessionProxy({
   appId: 'abstractcontinuum',
   defaultGatewayUrl: DEFAULT_GATEWAY_URL,
@@ -130,7 +237,18 @@ const gatewaySessionProxy = createGatewaySessionProxy({
 // Team page transport: /api/hub/* forwards an allowlisted hub API subset
 // with the OPERATOR seat's key attached server-side (proposal c1692,
 // agency contract c1696 — authorship stays the operator's own).
-const hubProxy = createHubProxy({ hubUrl: HUB_URL, seat: HUB_SEAT, keysPath: HUB_KEYS_PATH });
+// Every hub setting is a getter: a seat saved on the Settings page or with
+// `abstractcontinuum config set` applies without a restart.
+const hubProxy = createHubProxy({
+  hubUrl: () => settings.value('hub_url'),
+  seat: () => settings.value('hub_seat'),
+  keysPath: () => expand_home(settings.value('hub_keys')),
+  token: () => settings.value('hub_token'),
+  allowRemote: () => settings.value('hub_allow_remote'),
+});
+
+// The Settings page's door to this server's own settings (hub seat).
+const settingsRoute = createSettingsRoute({ live: settings });
 
 const server = http.createServer((req, res) => {
   // Parse against a FIXED base: a malformed Host header (e.g. "a b") makes
@@ -149,6 +267,10 @@ const server = http.createServer((req, res) => {
     return;
   }
 
+  if (settingsRoute.handle(req, res, pathname)) {
+    return;
+  }
+
   if (hubProxy.handle(req, res, pathname, search)) {
     return;
   }
@@ -195,10 +317,13 @@ server.on('upgrade', (req, socket, head) => {
 });
 
 server.listen(PORT, HOST, () => {
+  const seat = AT_START.hub_seat;
   console.log(`
 AbstractContinuum is running.
-  Local:   http://localhost:${PORT}
-  Gateway: ${DEFAULT_GATEWAY_URL}
+  Local:    http://localhost:${PORT}
+  Gateway:  ${DEFAULT_GATEWAY_URL}
+  Hub seat: ${seat.value} (${SOURCE_WORDS[seat.source]})
+  Settings: ${SETTINGS_PATH}
 `);
 });
 

package/bin/hub_proxy.js

@@ -4,14 +4,14 @@
  *
  * Serves /api/hub/* by forwarding an ALLOWLISTED subset of the hub HTTP
  * API with the OPERATOR seat's key attached server-side. The key comes
- * from the operator's standard key store (~/.agora/keys.json) or env; it
+ * from the operator's standard key store (~/.agora/keys.json) or the hub_token setting; it
  * never appears in the browser, a repo, or a URL (the c1556 rule
  * generalized from charter reads to the whole chat surface).
  *
  * Contract rules honored here (agency c1696):
  * - Only allowlisted paths forward — the proxy is a door, not a tunnel.
  * - GET /api/hub/meta names the seat so the UI can render authorship
- *   honestly ("posting as laurent").
+ *   honestly ("posting as <seat>").
  * - Ack/read_message are ordinary POSTs the UI calls on EXPLICIT read
  *   only (never on render) — enforced UI-side, but the proxy exposes
  *   them as distinct paths so an audit can see which fired.
@@ -214,10 +214,10 @@ function origin_allowed(req) {
   return Boolean(host) && parsed.host.toLowerCase() === host;
 }
 
-function read_seat_key(keys_path, hub_url, seat) {
-  // Env override wins (deployments without the operator key store).
-  const env_key = String(process.env.ABSTRACTCONTINUUM_HUB_KEY || '').trim();
-  if (env_key) return env_key;
+function read_seat_key(keys_path, hub_url, seat, token) {
+  // An explicit token (--hub-token / --hub-token-file / the hub_token
+  // setting, resolved by bin/settings.js) wins over the key store.
+  if (token) return token;
   try {
     const store = JSON.parse(readFileSync(keys_path, 'utf8'));
     const entry = store[`${hub_url}::${seat}`];
@@ -229,14 +229,32 @@ function read_seat_key(keys_path, hub_url, seat) {
   }
 }
 
+/** A value or a getter: the server hands getters so a seat saved on the
+ *  Settings page (or with `abstractcontinuum config set`) applies without
+ *  a restart. */
+function live(v) {
+  return typeof v === 'function' ? v() : v;
+}
+
+/**
+ * opts: hubUrl, seat, keysPath, token (seat API key; overrides the key
+ * store), allowRemote (boolean) — each a value or a getter. Settings are
+ * resolved by bin/settings.js (flag > setting > environment > default);
+ * this module reads no environment of its own.
+ */
 export function createHubProxy(opts) {
-  const hub_url = String(opts.hubUrl || '').replace(/\/+$/, '');
-  const seat = String(opts.seat || '').trim();
-  const keys_path = String(opts.keysPath || '');
+  const cfg = () => ({
+    hub_url: String(live(opts.hubUrl) || '').replace(/\/+$/, ''),
+    seat: String(live(opts.seat) || '').trim(),
+    keys_path: String(live(opts.keysPath) || ''),
+    token: String(live(opts.token) || '').trim(),
+    allow_remote: live(opts.allowRemote) === true,
+  });
 
   /** Lazily re-read per request: key rotation must not need a restart. */
   function key() {
-    return read_seat_key(keys_path, hub_url, seat);
+    const c = cfg();
+    return read_seat_key(c.keys_path, c.hub_url, c.seat, c.token);
   }
 
   async function forward(req, res, hub_path, search) {
@@ -290,7 +308,8 @@ export function createHubProxy(opts) {
     const seat_key = key();
     if (!seat_key && !route.keyless) {
       res.writeHead(503, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify({ error: 'hub_seat_unavailable', detail: `No hub key for seat "${seat}" (${keys_path}); set ABSTRACTCONTINUUM_HUB_KEY or provision the seat.` }));
+      const c = cfg();
+      res.end(JSON.stringify({ error: 'hub_seat_unavailable', detail: `No hub key for seat "${c.seat}" in ${c.keys_path}. Provision the seat there, or start Continuum with --hub-token-file <path>.` }));
       return;
     }
 
@@ -344,7 +363,7 @@ export function createHubProxy(opts) {
         // metadata). Every other write: application/json.
         upstream_headers['Content-Type'] = route.upload ? String(req.headers['content-type'] || 'application/octet-stream') : 'application/json';
       }
-      const r = await fetch(`${hub_url}${hub_path}${search || ''}`, {
+      const r = await fetch(`${cfg().hub_url}${hub_path}${search || ''}`, {
         method: req.method,
         headers: upstream_headers,
         body: body && req.method !== 'GET' ? body : undefined,
@@ -415,7 +434,7 @@ export function createHubProxy(opts) {
         // as the operator seat (adversary P0).
         const peer = String(req.socket && req.socket.remoteAddress ? req.socket.remoteAddress : '');
         const loopback = peer === '127.0.0.1' || peer === '::1' || peer === '::ffff:127.0.0.1' || peer === '';
-        const allow_remote = String(process.env.ABSTRACTCONTINUUM_HUB_ALLOW_REMOTE || '').trim() === '1';
+        const allow_remote = cfg().allow_remote;
         const seat_key = key();
         let WebSocketServer, WebSocket;
         try {
@@ -433,7 +452,7 @@ export function createHubProxy(opts) {
         // never negotiated (live find: browsers/ws clients offer it by
         // default and the pipe corrupts).
         if (!this._wss) this._wss = new WebSocketServer({ noServer: true, perMessageDeflate: false });
-        const hub_ws_url = hub_url.replace(/^http/, 'ws') + '/ws';
+        const hub_ws_url = cfg().hub_url.replace(/^http/, 'ws') + '/ws';
         const upstream = new WebSocket(hub_ws_url, {
           headers: { Authorization: `Bearer ${seat_key}` },
           perMessageDeflate: false,
@@ -521,10 +540,10 @@ export function createHubProxy(opts) {
       // this is defense-in-depth if HOST is widened deliberately.
       const peer = String(req.socket && req.socket.remoteAddress ? req.socket.remoteAddress : '');
       const loopback = peer === '127.0.0.1' || peer === '::1' || peer === '::ffff:127.0.0.1' || peer === '';
-      const allow_remote = String(process.env.ABSTRACTCONTINUUM_HUB_ALLOW_REMOTE || '').trim() === '1';
+      const allow_remote = cfg().allow_remote;
       if (!loopback && !allow_remote) {
         res.writeHead(403, { 'Content-Type': 'application/json' });
-        res.end(JSON.stringify({ error: 'hub_proxy_non_loopback', detail: `Hub proxy refuses non-loopback peer ${peer} (it authors as the operator seat). Set ABSTRACTCONTINUUM_HUB_ALLOW_REMOTE=1 only behind a trusted front.` }));
+        res.end(JSON.stringify({ error: 'hub_proxy_non_loopback', detail: `Hub proxy refuses non-loopback peer ${peer} (it authors as the operator seat). Start Continuum with --hub-allow-remote only behind a trusted front.` }));
         return true;
       }
       // Cross-origin browser requests are refused even from loopback: the
@@ -538,7 +557,8 @@ export function createHubProxy(opts) {
 
       if (pathname === '/api/hub/meta') {
         res.writeHead(200, { 'Content-Type': 'application/json' });
-        res.end(JSON.stringify({ ok: true, hub_url, seat, seat_key_present: Boolean(key()) }));
+        const c = cfg();
+        res.end(JSON.stringify({ ok: true, hub_url: c.hub_url, seat: c.seat, seat_key_present: Boolean(key()) }));
         return true;
       }
       const hub_path = pathname.slice('/api/hub'.length);